home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 24 / Amiga Format AFCD24 (Feb 1998, Issue 108).iso / -seriously_amiga- / shareware / programming / c / vbcc / pasm / instructions.c < prev    next >
C/C++ Source or Header  |  1998-01-05  |  38KB  |  1,139 lines
  1. /* $VER: pasm instructions.c V0.6 (30.10.97)
  2.  *
  3.  * This file is part of pasm, a portable PowerPC assembler.
  4.  * Copyright (c) 1997  Frank Wille
  5.  *
  6.  * pasm is freeware and part of the portable and retargetable ANSI C
  7.  * compiler vbcc, copyright (c) 1995-97 by Volker Barthelmann.
  8.  * pasm may be freely redistributed as long as no modifications are
  9.  * made and nothing is charged for it. Non-commercial usage is allowed
  10.  * without any restrictions.
  11.  * EVERY PRODUCT OR PROGRAM DERIVED DIRECTLY FROM MY SOURCE MAY NOT BE
  12.  * SOLD COMMERCIALLY WITHOUT PERMISSION FROM THE AUTHOR.
  13.  *
  14.  *
  15.  * v0.6 (30.10.97) phx
  16.  *      No more warnings for val@l(rA), where val is > 0x7fff.
  17.  *      Warnings for optional, 64-bit and supervisor instructions
  18.  *      can be suppressed.
  19.  * v0.5 (03.10.97) phx
  20.  *      Auto-converting (rA) into 0(rA) had lead to conflicts with terms.
  21.  *      For example: (x+y)(rA)
  22.  * v0.4 (05.07.97) phx
  23.  *      AA bit in BC instructions is set to allow correct EHF reloction
  24.  *      (by using AmigaDOS HUNK_RELRELOC16. This should be no problem,
  25.  *      because absolute branches are not supported by EHF anyway.
  26.  *      Branch prediction with BCA didn't work correctly.
  27.  *      Relative branches into other sections are allowed, but the
  28.  *      user will be warned, because not all object formats / linkers
  29.  *      support it.
  30.  *      Omitting zero in load/store instructions is allowed, e.g.
  31.  *      "rD,(rA)" will be converted into "rD,0(rA)".
  32.  *      R_PPC_TOC16 support for T_DD- and T_DS-type instructions.
  33.  * v0.3 (05.04.97) phx
  34.  *      An external symbol@l/h/ha, used in d(Rn) addressing mode, got
  35.  *      R_PPC_ADDR16 relocation instead R_PPC_ADDR16_LO/HI/HA.
  36.  *      Little-endian support.
  37.  * v0.2 (25.03.97) phx
  38.  *      Writes ELF object for 32-bit PowerPC big-endian. Either absolute
  39.  *      or ELF output format may be selected. ELF is default for all
  40.  *      currently supported platforms. PPCasm supports nine different
  41.  *      relocation types (there are much more...).
  42.  *      Compiles and works also under NetBSD/amiga (68k).
  43.  *      Changed function declaration to 'new style' in all sources
  44.  *      (to avoid problems with '...' for example).
  45.  *      @l/h/ha is allowed for all displacements.
  46.  * v0.1 (11.03.97) phx
  47.  *      First test version with all PowerPC instructions and most
  48.  *      important directives. Only raw, absolute output.
  49.  *      Although all 32- and 64-bit PowerPC instructions are imple-
  50.  *      mented, too few are really tested till now. I'm expecting many
  51.  *      bugs in this long list.
  52.  *      'la' is the only extended mnemonic, which was implemented as a
  53.  *      real instruction and not by a macro. It is possible to imple-
  54.  *      ment all extended mnemonics here, but it would be much work.
  55.  *      Maybe later, to improve speed. ;)
  56.  * v0.0 (21.02.97) phx
  57.  *      File created.
  58.  */
  59.  
  60.  
  61. #define INSTRUCTIONS_C
  62. #include "ppcasm.h"
  63.  
  64.  
  65. void instr(struct GlobalVars *,struct ParsedLine *);
  66. char *check_comma(char *);
  67. void pcadd(struct GlobalVars *,unsigned long);
  68. void store_byte(struct GlobalVars *,uint8);
  69. void store_half(struct GlobalVars *,uint16);
  70. void store_word(struct GlobalVars *,uint32);
  71. void store_float(struct GlobalVars *,double);
  72. void store_double(struct GlobalVars *,double);
  73. void store_space(struct GlobalVars *,unsigned long);
  74.  
  75. static void swapops(uint32 *,uint32 *);
  76. static int count_operands(struct GlobalVars *,char *);
  77. static bool chk_regindir(char *);
  78.  
  79.  
  80.  
  81. struct CPUInstr instructions[] = {
  82.   /* standard PowerPC instruction set */
  83.   { 0,"add",0,T_X,31,0,0,(0<<10)+(266<<1)+0 },
  84.   { 0,"add.",0,T_X,31,0,0,(0<<10)+(266<<1)+1 },
  85.   { 0,"addo",0,T_X,31,0,0,(1<<10)+(266<<1)+0 },
  86.   { 0,"addo.",0,T_X,31,0,0,(1<<10)+(266<<1)+1 },
  87.   { 0,"addc",0,T_X,31,0,0,(0<<10)+(10<<1)+0 },
  88.   { 0,"addc.",0,T_X,31,0,0,(0<<10)+(10<<1)+1 },
  89.   { 0,"addco",0,T_X,31,0,0,(1<<10)+(10<<1)+0 },
  90.   { 0,"addco.",0,T_X,31,0,0,(1<<10)+(10<<1)+1 },
  91.   { 0,"adde",0,T_X,31,0,0,(0<<10)+(138<<1)+0 },
  92.   { 0,"adde.",0,T_X,31,0,0,(0<<10)+(138<<1)+1 },
  93.   { 0,"addeo",0,T_X,31,0,0,(1<<10)+(138<<1)+0 },
  94.   { 0,"addeo.",0,T_X,31,0,0,(1<<10)+(138<<1)+1 },
  95.   { 0,"addi",F_SIGNED,T_DI,14,0,0,0 },
  96.   { 0,"addic",F_SIGNED,T_DI,12,0,0,0 },
  97.   { 0,"addic.",F_SIGNED,T_DI,13,0,0,0 },
  98.   { 0,"addis",F_SIGNED,T_DI,15,0,0,0 },
  99.   { 0,"addme",F_SUPP_B,T_X,31,0,0,(0<<10)+(234<<1)+0 },
  100.   { 0,"addme.",F_SUPP_B,T_X,31,0,0,(0<<10)+(234<<1)+1 },
  101.   { 0,"addmeo",F_SUPP_B,T_X,31,0,0,(1<<10)+(234<<1)+0 },
  102.   { 0,"addmeo.",F_SUPP_B,T_X,31,0,0,(1<<10)+(234<<1)+1 },
  103.   { 0,"addze",F_SUPP_B,T_X,31,0,0,(0<<10)+(202<<1)+0 },
  104.   { 0,"addze.",F_SUPP_B,T_X,31,0,0,(0<<10)+(202<<1)+1 },
  105.   { 0,"addzeo",F_SUPP_B,T_X,31,0,0,(1<<10)+(202<<1)+0 },
  106.   { 0,"addzeo.",F_SUPP_B,T_X,31,0,0,(1<<10)+(202<<1)+1 },
  107.   { 0,"and",F_SWAP,T_X,31,0,0,(28<<1)+0 },
  108.   { 0,"and.",F_SWAP,T_X,31,0,0,(28<<1)+1 },
  109.   { 0,"andc",F_SWAP,T_X,31,0,0,(60<<1)+0 },
  110.   { 0,"andc.",F_SWAP,T_X,31,0,0,(60<<1)+1 },
  111.   { 0,"andi.",F_SWAP,T_DI,28,0,0,0 },
  112.   { 0,"andis.",F_SWAP,T_DI,29,0,0,0 },
  113.   { 0,"b",F_SIGNED,T_I,18,0,0,0 },
  114.   { 0,"bl",F_SIGNED,T_I,18,0,0,1 },
  115.   { 0,"ba",0,T_I,18,0,0,2 },
  116.   { 0,"bla",0,T_I,18,0,0,3 },
  117.   { 0,"bc",F_SIGNED,T_B,16,0,0,0 },
  118.   { 0,"bcl",F_SIGNED,T_B,16,0,0,1 },
  119.   { 0,"bca",0,T_B,16,0,0,2 },
  120.   { 0,"bcla",0,T_B,16,0,0,3 },
  121.   { 0,"bcctr",0,T_XLB,19,0,0,(528<<1)+0 },
  122.   { 0,"bcctrl",0,T_XLB,19,0,0,(528<<1)+1 },
  123.   { 0,"bclr",0,T_XLB,19,0,0,(16<<1)+0 },
  124.   { 0,"bclrl",0,T_XLB,19,0,0,(16<<1)+1 },
  125.   { 0,"cmp",0,T_CMP,31,0,0,(0<<1) },
  126.   { 0,"cmpl",0,T_CMP,31,0,0,(32<<1) },
  127.   { 0,"cmpi",F_SIGNED|F_SUPP_B,T_CMP,11,0,0,0 },
  128.   { 0,"cmpli",F_SUPP_B,T_CMP,10,0,0,0 },
  129.   { 0,"cntlzd",F_SWAP|F_SUPP_B|F_64BIT,T_X,31,0,0,(58<<1)+0 },
  130.   { 0,"cntlzd.",F_SWAP|F_SUPP_B|F_64BIT,T_X,31,0,0,(58<<1)+1 },
  131.   { 0,"cntlzw",F_SWAP|F_SUPP_B,T_X,31,0,0,(26<<1)+0 },
  132.   { 0,"cntlzw.",F_SWAP|F_SUPP_B,T_X,31,0,0,(26<<1)+1 },
  133.   { 0,"crand",0,T_X,19,0,0,(257<<1) },
  134.   { 0,"crandc",0,T_X,19,0,0,(129<<1) },
  135.   { 0,"creqv",0,T_X,19,0,0,(289<<1) },
  136.   { 0,"crnand",0,T_X,19,0,0,(225<<1) },
  137.   { 0,"crnor",0,T_X,19,0,0,(33<<1) },
  138.   { 0,"cror",0,T_X,19,0,0,(449<<1) },
  139.   { 0,"crorc",0,T_X,19,0,0,(417<<1) },
  140.   { 0,"crxor",0,T_X,19,0,0,(193<<1) },
  141.   { 0,"dcbf",F_SUPP_D,T_X,31,0,0,(86<<1) },
  142.   { 0,"dcbi",F_SUPP_D|F_SUPER,T_X,31,0,0,(470<<1) },
  143.   { 0,"dcbst",F_SUPP_D,T_X,31,0,0,(54<<1) },
  144.   { 0,"dcbt",F_SUPP_D,T_X,31,0,0,(278<<1) },
  145.   { 0,"dcbtst",F_SUPP_D,T_X,31,0,0,(246<<1) },
  146.   { 0,"dcbz",F_SUPP_D,T_X,31,0,0,(1014<<1) },
  147.   { 0,"divd",F_64BIT,T_X,31,0,0,(0<<10)+(489<<1)+0 },
  148.   { 0,"divd.",F_64BIT,T_X,31,0,0,(0<<10)+(489<<1)+1 },
  149.   { 0,"divdo",F_64BIT,T_X,31,0,0,(1<<10)+(489<<1)+0 },
  150.   { 0,"divdo.",F_64BIT,T_X,31,0,0,(1<<10)+(489<<1)+1 },
  151.   { 0,"divdu",F_64BIT,T_X,31,0,0,(0<<10)+(457<<1)+0 },
  152.   { 0,"divdu.",F_64BIT,T_X,31,0,0,(0<<10)+(457<<1)+1 },
  153.   { 0,"divduo",F_64BIT,T_X,31,0,0,(1<<10)+(457<<1)+0 },
  154.   { 0,"divduo.",F_64BIT,T_X,31,0,0,(1<<10)+(457<<1)+1 },
  155.   { 0,"divw",0,T_X,31,0,0,(0<<10)+(491<<1)+0 },
  156.   { 0,"divw.",0,T_X,31,0,0,(0<<10)+(491<<1)+1 },
  157.   { 0,"divwo",0,T_X,31,0,0,(1<<10)+(491<<1)+0 },
  158.   { 0,"divwo.",0,T_X,31,0,0,(1<<10)+(491<<1)+1 },
  159.   { 0,"divwu",0,T_X,31,0,0,(0<<10)+(459<<1)+0 },
  160.   { 0,"divwu.",0,T_X,31,0,0,(0<<10)+(459<<1)+1 },
  161.   { 0,"divwuo",0,T_X,31,0,0,(1<<10)+(459<<1)+0 },
  162.   { 0,"divwuo.",0,T_X,31,0,0,(1<<10)+(459<<1)+1 },
  163.   { 0,"eciwx",0,T_X,31,0,0,(310<<1) },
  164.   { 0,"ecowx",0,T_X,31,0,0,(438<<1) },
  165.   { 0,"eieio",F_SUPP_D|F_SUPP_A|F_SUPP_B,T_X,31,0,0,(854<<1) },
  166.   { 0,"eqv",F_SWAP,T_X,31,0,0,(284<<1)+0 },
  167.   { 0,"eqv.",F_SWAP,T_X,31,0,0,(284<<1)+0 },
  168.   { 0,"extsb",F_SWAP|F_SUPP_B,T_X,31,0,0,(954<<1)+0 },
  169.   { 0,"extsb.",F_SWAP|F_SUPP_B,T_X,31,0,0,(954<<1)+1 },
  170.   { 0,"extsh",F_SWAP|F_SUPP_B,T_X,31,0,0,(922<<1)+0 },
  171.   { 0,"extsh.",F_SWAP|F_SUPP_B,T_X,31,0,0,(922<<1)+1 },
  172.   { 0,"extsw",F_SWAP|F_SUPP_B|F_64BIT,T_X,31,0,0,(986<<1)+0 },
  173.   { 0,"extsw.",F_SWAP|F_SUPP_B|F_64BIT,T_X,31,0,0,(986<<1)+1 },
  174.   { 0,"fabs",F_SUPP_A,T_X,63,0,0,(264<<1)+0 },
  175.   { 0,"fabs.",F_SUPP_A,T_X,63,0,0,(264<<1)+1 },
  176.   { 0,"fadd",F_SUPP_C,T_A,63,0,0,(21<<1)+0 },
  177.   { 0,"fadd.",F_SUPP_C,T_A,63,0,0,(21<<1)+1 },
  178.   { 0,"fadds",F_SUPP_C,T_A,59,0,0,(21<<1)+0 },
  179.   { 0,"fadds.",F_SUPP_C,T_A,59,0,0,(21<<1)+1 },
  180.   { 0,"fcfid",F_SUPP_A|F_64BIT,T_X,63,0,0,(846<<1)+0 },
  181.   { 0,"fcfid.",F_SUPP_A|F_64BIT,T_X,63,0,0,(846<<1)+1 },
  182.   { 0,"fcmpo",F_CRF_D,T_X,63,0,0,(32<<1) },
  183.   { 0,"fcmpu",F_CRF_D,T_X,63,0,0,(0<<1) },
  184.   { 0,"fctid",F_SUPP_A|F_64BIT,T_X,63,0,0,(814<<1)+0 },
  185.   { 0,"fctid.",F_SUPP_A|F_64BIT,T_X,63,0,0,(814<<1)+1 },
  186.   { 0,"fctidz",F_SUPP_A|F_64BIT,T_X,63,0,0,(815<<1)+0 },
  187.   { 0,"fctidz.",F_SUPP_A|F_64BIT,T_X,63,0,0,(815<<1)+1 },
  188.   { 0,"fctiw",F_SUPP_A,T_X,63,0,0,(14<<1)+0 },
  189.   { 0,"fctiw.",F_SUPP_A,T_X,63,0,0,(14<<1)+1 },
  190.   { 0,"fctiwz",F_SUPP_A,T_X,63,0,0,(15<<1)+0 },
  191.   { 0,"fctiwz.",F_SUPP_A,T_X,63,0,0,(15<<1)+1 },
  192.   { 0,"fdiv",F_SUPP_C,T_A,63,0,0,(18<<1)+0 },
  193.   { 0,"fdiv.",F_SUPP_C,T_A,63,0,0,(18<<1)+1 },
  194.   { 0,"fdivs",F_SUPP_C,T_A,59,0,0,(18<<1)+0 },
  195.   { 0,"fdivs.",F_SUPP_C,T_A,59,0,0,(18<<1)+1 },
  196.   { 0,"fmadd",0,T_A,63,0,0,(29<<1)+0 },
  197.   { 0,"fmadd.",0,T_A,63,0,0,(29<<1)+1 },
  198.   { 0,"fmadds",0,T_A,59,0,0,(29<<1)+0 },
  199.   { 0,"fmadds.",0,T_A,59,0,0,(29<<1)+1 },
  200.   { 0,"fmr",F_SUPP_A,T_X,63,0,0,(72<<1)+0 },
  201.   { 0,"fmr.",F_SUPP_A,T_X,63,0,0,(72<<1)+1 },
  202.   { 0,"fmsub",0,T_A,63,0,0,(28<<1)+0 },
  203.   { 0,"fmsub.",0,T_A,63,0,0,(28<<1)+1 },
  204.   { 0,"fmsubs",0,T_A,59,0,0,(28<<1)+0 },
  205.   { 0,"fmsubs.",0,T_A,59,0,0,(28<<1)+1 },
  206.   { 0,"fmul",F_SUPP_B,T_A,63,0,0,(25<<1)+0 },
  207.   { 0,"fmul.",F_SUPP_B,T_A,63,0,0,(25<<1)+1 },
  208.   { 0,"fmuls",F_SUPP_B,T_A,59,0,0,(25<<1)+0 },
  209.   { 0,"fmuls.",F_SUPP_B,T_A,59,0,0,(25<<1)+1 },
  210.   { 0,"fnabs",F_SUPP_A,T_X,63,0,0,(136<<1)+0 },
  211.   { 0,"fnabs.",F_SUPP_A,T_X,63,0,0,(136<<1)+1 },
  212.   { 0,"fneg",F_SUPP_A,T_X,63,0,0,(40<<1)+0 },
  213.   { 0,"fneg.",F_SUPP_A,T_X,63,0,0,(40<<1)+1 },
  214.   { 0,"fnmadd",0,T_A,63,0,0,(31<<1)+0 },
  215.   { 0,"fnmadd.",0,T_A,63,0,0,(31<<1)+1 },
  216.   { 0,"fnmadds",0,T_A,59,0,0,(31<<1)+0 },
  217.   { 0,"fnmadds.",0,T_A,59,0,0,(31<<1)+1 },
  218.   { 0,"fnmsub",0,T_A,63,0,0,(30<<1)+0 },
  219.   { 0,"fnmsub.",0,T_A,63,0,0,(30<<1)+1 },
  220.   { 0,"fnmsubs",0,T_A,59,0,0,(30<<1)+0 },
  221.   { 0,"fnmsubs.",0,T_A,59,0,0,(30<<1)+1 },
  222.   { 0,"fres",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,59,0,0,(24<<1)+0 },
  223.   { 0,"fres.",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,59,0,0,(24<<1)+1 },
  224.   { 0,"frsp",F_SUPP_A,T_X,63,0,0,(12<<1)+0 },
  225.   { 0,"frsp.",F_SUPP_A,T_X,63,0,0,(12<<1)+1 },
  226.   { 0,"frsqrte",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,63,0,0,(26<<1)+0 },
  227.   { 0,"frsqrte.",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,63,0,0,(26<<1)+1 },
  228.   { 0,"fsel",F_OPTIONAL,T_A,63,0,0,(23<<1)+0 },
  229.   { 0,"fsel.",F_OPTIONAL,T_A,63,0,0,(23<<1)+1 },
  230.   { 0,"fsqrt",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,63,0,0,(22<<1)+0 },
  231.   { 0,"fsqrt.",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,63,0,0,(22<<1)+1 },
  232.   { 0,"fsqrts",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,59,0,0,(22<<1)+0 },
  233.   { 0,"fsqrts.",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,59,0,0,(22<<1)+1 },
  234.   { 0,"fsub",F_SUPP_C,T_A,63,0,0,(20<<1)+0 },
  235.   { 0,"fsub.",F_SUPP_C,T_A,63,0,0,(20<<1)+1 },
  236.   { 0,"fsubs",F_SUPP_C,T_A,59,0,0,(20<<1)+0 },
  237.   { 0,"fsubs.",F_SUPP_C,T_A,59,0,0,(20<<1)+1 },
  238.   { 0,"icbi",F_SUPP_D,T_X,31,0,0,(982<<1) },
  239.   { 0,"isync",F_SUPP_D|F_SUPP_A|F_SUPP_B,T_X,19,0,0,(150<<1) },
  240.   { 0,"lbz",0,T_DD,34,0,0,0 },
  241.   { 0,"lbzu",0,T_DD,35,0,0,0 },
  242.   { 0,"lbzux",0,T_X,31,0,0,(119<<1) },
  243.   { 0,"lbzx",0,T_X,31,0,0,(87<<1) },
  244.   { 0,"ld",F_64BIT,T_DS,58,0,0,0 },
  245.   { 0,"ldarx",F_64BIT,T_X,31,0,0,(84<<1) },
  246.   { 0,"ldu",F_64BIT,T_DS,58,0,0,1 },
  247.   { 0,"ldux",F_64BIT,T_X,31,0,0,(53<<1) },
  248.   { 0,"ldx",F_64BIT,T_X,31,0,0,(21<<1) },
  249.   { 0,"lfd",0,T_DD,50,0,0,0 },
  250.   { 0,"lfdu",0,T_DD,51,0,0,0 },
  251.   { 0,"lfdux",0,T_X,31,0,0,(631<<1) },
  252.   { 0,"lfdx",0,T_X,31,0,0,(599<<1) },
  253.   { 0,"lfs",0,T_DD,48,0,0,0 },
  254.   { 0,"lfsu",0,T_DD,49,0,0,0 },
  255.   { 0,"lfsux",0,T_X,31,0,0,(567<<1) },
  256.   { 0,"lfsx",0,T_X,31,0,0,(535<<1) },
  257.   { 0,"lha",0,T_DD,42,0,0,0 },
  258.   { 0,"lhau",0,T_DD,43,0,0,0 },
  259.   { 0,"lhaux",0,T_X,31,0,0,(375<<1) },
  260.   { 0,"lhax",0,T_X,31,0,0,(343<<1) },
  261.   { 0,"lhbrx",0,T_X,31,0,0,(790<<1) },
  262.   { 0,"lhz",0,T_DD,40,0,0,0 },
  263.   { 0,"lhzu",0,T_DD,41,0,0,0 },
  264.   { 0,"lhzux",0,T_X,31,0,0,(311<<1) },
  265.   { 0,"lhzx",0,T_X,31,0,0,(279<<1) },
  266.   { 0,"lmw",0,T_DD,46,0,0,0 },
  267.   { 0,"lswi",0,T_X,31,0,0,(597<<1) },
  268.   { 0,"lswx",0,T_X,31,0,0,(533<<1) },
  269.   { 0,"lwa",F_64BIT,T_DS,58,0,0,2 },
  270.   { 0,"lwarx",0,T_X,31,0,0,(20<<1) },
  271.   { 0,"lwaux",F_64BIT,T_X,31,0,0,(373<<1) },
  272.   { 0,"lwax",F_64BIT,T_X,31,0,0,(341<<1) },
  273.   { 0,"lwbrx",0,T_X,31,0,0,(534<<1) },
  274.   { 0,"lwz",0,T_DD,32,0,0,0 },
  275.   { 0,"lwzu",0,T_DD,33,0,0,0 },
  276.   { 0,"lwzux",0,T_X,31,0,0,(55<<1) },
  277.   { 0,"lwzx",0,T_X,31,0,0,(23<<1) },
  278.   { 0,"mcrf",F_CRF_D|F_CRF_S|F_SUPP_B,T_X,19,0,0,(0<<1) },
  279.   { 0,"mcrfs",F_CRF_D|F_CRF_S|F_SUPP_B,T_X,63,0,0,(64<<1) },
  280.   { 0,"mcrxr",F_CRF_D|F_SUPP_A|F_SUPP_B,T_X,31,0,0,(512<<1) },
  281.   { 0,"mfcr",F_SUPP_A|F_SUPP_B,T_X,31,0,0,(19<<1) },
  282.   { 0,"mffs",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(583<<1)+0 },
  283.   { 0,"mffs.",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(583<<1)+1 },
  284.   { 0,"mfmsr",F_SUPP_A|F_SUPP_B|F_SUPER,T_X,31,0,0,(83<<1) },
  285.   { 0,"mfspr",0,T_XSPR,31,0,0,(339<<1) },
  286.   { 0,"mfsr",F_SUPP_B|F_SUPER,T_X,31,0,0,(595<<1) },
  287.   { 0,"mfsrin",F_SUPP_A|F_SUPER,T_X,31,0,0,(659<<1) },
  288.   { 0,"mftb",0,T_XSPR,31,0,0,(371<<1) },
  289.   { 0,"mtcrf",0,T_XCRM,31,0,0,(144<<1) },
  290.   { 0,"mtfsb0",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(70<<1)+0 },
  291.   { 0,"mtfsb0.",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(70<<1)+1 },
  292.   { 0,"mtfsb1",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(38<<1)+0 },
  293.   { 0,"mtfsb1.",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(38<<1)+1 },
  294.   { 0,"mtfsf",0,T_XFL,63,0,0,(711<<1)+0 },
  295.   { 0,"mtfsf.",0,T_XFL,63,0,0,(711<<1)+1 },
  296.   { 0,"mtfsfi",0,T_IMM,63,0,0,(134<<1)+0 },
  297.   { 0,"mtfsfi.",0,T_IMM,63,0,0,(134<<1)+1 },
  298.   { 0,"mtmsr",F_SUPP_A|F_SUPP_B|F_SUPER,T_X,31,0,0,(146<<1) },
  299.   { 0,"mtspr",F_SWAP,T_XSPR,31,0,0,(467<<1) },
  300.   { 0,"mtsr",F_SWAP|F_SUPP_B|F_SUPER,T_X,31,0,0,(210<<1) },
  301.   { 0,"mtsrin",F_SUPP_A,T_X,31,0,0,(242<<1) },
  302.   { 0,"mulhd",F_64BIT,T_X,31,0,0,(73<<1)+0 },
  303.   { 0,"mulhd.",F_64BIT,T_X,31,0,0,(73<<1)+1 },
  304.   { 0,"mulhdu",F_64BIT,T_X,31,0,0,(9<<1)+0 },
  305.   { 0,"mulhdu.",F_64BIT,T_X,31,0,0,(9<<1)+1 },
  306.   { 0,"mulhw",0,T_X,31,0,0,(75<<1)+0 },
  307.   { 0,"mulhw.",0,T_X,31,0,0,(75<<1)+1 },
  308.   { 0,"mulhwu",0,T_X,31,0,0,(11<<1)+0 },
  309.   { 0,"mulhwu.",0,T_X,31,0,0,(11<<1)+1 },
  310.   { 0,"mulld",F_64BIT,T_X,31,0,0,(0<<10)+(233<<1)+0 },
  311.   { 0,"mulld.",F_64BIT,T_X,31,0,0,(0<<10)+(233<<1)+1 },
  312.   { 0,"mulldo",F_64BIT,T_X,31,0,0,(1<<10)+(233<<1)+0 },
  313.   { 0,"mulldo.",F_64BIT,T_X,31,0,0,(1<<10)+(233<<1)+1 },
  314.   { 0,"mulli",F_SIGNED,T_DI,7,0,0,0 },
  315.   { 0,"mullw",0,T_X,31,0,0,(0<<10)+(235<<1)+0 },
  316.   { 0,"mullw.",0,T_X,31,0,0,(0<<10)+(235<<1)+1 },
  317.   { 0,"mullwo",0,T_X,31,0,0,(1<<10)+(235<<1)+0 },
  318.   { 0,"mullwo.",0,T_X,31,0,0,(1<<10)+(235<<1)+1 },
  319.   { 0,"nand",F_SWAP,T_X,31,0,0,(476<<1)+0 },
  320.   { 0,"nand.",F_SWAP,T_X,31,0,0,(476<<1)+1 },
  321.   { 0,"neg",F_SUPP_B,T_X,31,0,0,(0<<10)+(104<<1)+0 },
  322.   { 0,"neg.",F_SUPP_B,T_X,31,0,0,(0<<10)+(104<<1)+1 },
  323.   { 0,"nego",F_SUPP_B,T_X,31,0,0,(1<<10)+(104<<1)+0 },
  324.   { 0,"nego.",F_SUPP_B,T_X,31,0,0,(1<<10)+(104<<1)+1 },
  325.   { 0,"nor",F_SWAP,T_X,31,0,0,(124<<1)+0 },
  326.   { 0,"nor.",F_SWAP,T_X,31,0,0,(124<<1)+1 },
  327.   { 0,"or",F_SWAP,T_X,31,0,0,(444<<1)+0 },
  328.   { 0,"or.",F_SWAP,T_X,31,0,0,(444<<1)+1 },
  329.   { 0,"orc",F_SWAP,T_X,31,0,0,(412<<1)+0 },
  330.   { 0,"orc.",F_SWAP,T_X,31,0,0,(412<<1)+1 },
  331.   { 0,"ori",F_SWAP,T_DI,24,0,0,0 },
  332.   { 0,"oris",F_SWAP,T_DI,25,0,0,0 },
  333.   { 0,"rfi",F_SUPP_D|F_SUPP_A|F_SUPP_B|F_SUPER,T_X,19,0,0,(50<<1) },
  334.   { 0,"rldcl",F_SWAP|F_64BIT,T_A,30,0,0,(8<<1)+0 },
  335.   { 0,"rldcl.",F_SWAP|F_64BIT,T_A,30,0,0,(8<<1)+1 },
  336.   { 0,"rldcr",F_SWAP|F_64BIT,T_A,30,0,0,(9<<1)+0 },
  337.   { 0,"rldcr.",F_SWAP|F_64BIT,T_A,30,0,0,(9<<1)+1 },
  338.   { 0,"rldic",F_64BIT,T_MD,30,0,0,(2<<2)+0 },
  339.   { 0,"rldic.",F_64BIT,T_MD,30,0,0,(2<<2)+1 },
  340.   { 0,"rldicl",F_64BIT,T_MD,30,0,0,(0<<2)+0 },
  341.   { 0,"rldicl.",F_64BIT,T_MD,30,0,0,(0<<2)+1 },
  342.   { 0,"rldicr",F_64BIT,T_MD,30,0,0,(1<<2)+0 },
  343.   { 0,"rldicr.",F_64BIT,T_MD,30,0,0,(1<<2)+1 },
  344.   { 0,"rldimi",F_64BIT,T_MD,30,0,0,(3<<2)+0 },
  345.   { 0,"rldimi.",F_64BIT,T_MD,30,0,0,(3<<2)+1 },
  346.   { 0,"rlwimi",0,T_M,20,0,0,0 },
  347.   { 0,"rlwimi.",0,T_M,20,0,0,1 },
  348.   { 0,"rlwinm",0,T_M,21,0,0,0 },
  349.   { 0,"rlwinm.",0,T_M,21,0,0,1 },
  350.   { 0,"rlwnm",0,T_M,23,0,0,0 },
  351.   { 0,"rlwnm.",0,T_M,23,0,0,1 },
  352.   { 0,"sc",F_SUPP_D|F_SUPP_A|F_SUPP_B,T_X,17,0,0,2 },
  353.   { 0,"slbia",F_SUPP_D|F_SUPP_A|F_SUPP_B|F_SUPER|F_64BIT|F_OPTIONAL,
  354.     T_X,31,0,0,(498<<1) },
  355.   { 0,"slbie",F_SUPP_D|F_SUPP_A|F_SUPER|F_64BIT|F_OPTIONAL,
  356.     T_X,31,0,0,(434<<1) },
  357.   { 0,"sld",F_SWAP|F_64BIT,T_X,31,0,0,(27<<1)+0 },
  358.   { 0,"sld.",F_SWAP|F_64BIT,T_X,31,0,0,(27<<1)+1 },
  359.   { 0,"slw",F_SWAP,T_X,31,0,0,(24<<1)+0 },
  360.   { 0,"slw.",F_SWAP,T_X,31,0,0,(24<<1)+1 },
  361.   { 0,"srad",F_SWAP|F_64BIT,T_X,31,0,0,(794<<1)+0 },
  362.   { 0,"srad.",F_SWAP|F_64BIT,T_X,31,0,0,(794<<1)+1 },
  363.   { 0,"sradi",F_64BIT,T_XS,31,0,0,(413<<2)+0 },
  364.   { 0,"sradi.",F_64BIT,T_XS,31,0,0,(413<<2)+1 },
  365.   { 0,"sraw",F_SWAP,T_X,31,0,0,(792<<1)+0 },
  366.   { 0,"sraw.",F_SWAP,T_X,31,0,0,(792<<1)+1 },
  367.   { 0,"srawi",F_SWAP,T_X,31,0,0,(824<<1)+0 },
  368.   { 0,"srawi.",F_SWAP,T_X,31,0,0,(824<<1)+1 },
  369.   { 0,"srd",F_SWAP|F_64BIT,T_X,31,0,0,(539<<1)+0 },
  370.   { 0,"srd.",F_SWAP|F_64BIT,T_X,31,0,0,(539<<1)+1 },
  371.   { 0,"srw",F_SWAP,T_X,31,0,0,(536<<1)+0 },
  372.   { 0,"srw.",F_SWAP,T_X,31,0,0,(536<<1)+1 },
  373.   { 0,"stb",0,T_DD,38,0,0,0 },
  374.   { 0,"stbu",0,T_DD,39,0,0,0 },
  375.   { 0,"stbux",0,T_X,31,0,0,(247<<1) },
  376.   { 0,"stbx",0,T_X,31,0,0,(215<<1) },
  377.   { 0,"std",F_64BIT,T_DS,62,0,0,0 },
  378.   { 0,"stdcx.",F_64BIT,T_X,31,0,0,(214<<1)+1 },
  379.   { 0,"stdu",F_64BIT,T_DS,62,0,0,1 },
  380.   { 0,"stdux",F_64BIT,T_X,31,0,0,(181<<1) },
  381.   { 0,"stdx",F_64BIT,T_X,31,0,0,(149<<1) },
  382.   { 0,"stfd",0,T_DD,54,0,0,0 },
  383.   { 0,"stfdu",0,T_DD,55,0,0,0 },
  384.   { 0,"stfdux",0,T_X,31,0,0,(759<<1) },
  385.   { 0,"stfdx",0,T_X,31,0,0,(727<<1) },
  386.   { 0,"stfiwx",F_OPTIONAL,T_X,31,0,0,(983<<1) },
  387.   { 0,"stfs",0,T_DD,52,0,0,0 },
  388.   { 0,"stfsu",0,T_DD,53,0,0,0 },
  389.   { 0,"stfsux",0,T_X,31,0,0,(695<<1) },
  390.   { 0,"stfsx",0,T_X,31,0,0,(663<<1) },
  391.   { 0,"sth",0,T_DD,44,0,0,0 },
  392.   { 0,"sthbrx",0,T_X,31,0,0,(918<<1) },
  393.   { 0,"sthu",0,T_DD,45,0,0,0 },
  394.   { 0,"sthux",0,T_X,31,0,0,(439<<1) },
  395.   { 0,"sthx",0,T_X,31,0,0,(407<<1) },
  396.   { 0,"stmw",0,T_DD,47,0,0,0 },
  397.   { 0,"stswi",0,T_X,31,0,0,(725<<1) },
  398.   { 0,"stswx",0,T_X,31,0,0,(661<<1) },
  399.   { 0,"stw",0,T_DD,36,0,0,0 },
  400.   { 0,"stwbrx",0,T_X,31,0,0,(662<<1) },
  401.   { 0,"stwcx.",0,T_X,31,0,0,(150<<1)+1 },
  402.   { 0,"stwu",0,T_DD,37,0,0,0 },
  403.   { 0,"stwux",0,T_X,31,0,0,(183<<1) },
  404.   { 0,"stwx",0,T_X,31,0,0,(151<<1) },
  405.   { 0,"subf",0,T_X,31,0,0,(0<<10)+(40<<1)+0 },
  406.   { 0,"subf.",0,T_X,31,0,0,(0<<10)+(40<<1)+1 },
  407.   { 0,"subfo",0,T_X,31,0,0,(1<<10)+(40<<1)+0 },
  408.   { 0,"subfo.",0,T_X,31,0,0,(1<<10)+(40<<1)+1 },
  409.   { 0,"subfc",0,T_X,31,0,0,(0<<10)+(8<<1)+0 },
  410.   { 0,"subfc.",0,T_X,31,0,0,(0<<10)+(8<<1)+1 },
  411.   { 0,"subfco",0,T_X,31,0,0,(1<<10)+(8<<1)+0 },
  412.   { 0,"subfco.",0,T_X,31,0,0,(1<<10)+(8<<1)+1 },
  413.   { 0,"subfe",0,T_X,31,0,0,(0<<10)+(136<<1)+0 },
  414.   { 0,"subfe.",0,T_X,31,0,0,(0<<10)+(136<<1)+1 },
  415.   { 0,"subfeo",0,T_X,31,0,0,(1<<10)+(136<<1)+0 },
  416.   { 0,"subfeo.",0,T_X,31,0,0,(1<<10)+(136<<1)+1 },
  417.   { 0,"subfic",F_SIGNED,T_DI,8,0,0,0 },
  418.   { 0,"subfme",F_SUPP_B,T_X,31,0,0,(0<<10)+(232<<1)+0 },
  419.   { 0,"subfme.",F_SUPP_B,T_X,31,0,0,(0<<10)+(232<<1)+1 },
  420.   { 0,"subfmeo",F_SUPP_B,T_X,31,0,0,(1<<10)+(232<<1)+0 },
  421.   { 0,"subfmeo.",F_SUPP_B,T_X,31,0,0,(1<<10)+(232<<1)+1 },
  422.   { 0,"subfze",F_SUPP_B,T_X,31,0,0,(0<<10)+(200<<1)+0 },
  423.   { 0,"subfze.",F_SUPP_B,T_X,31,0,0,(0<<10)+(200<<1)+1 },
  424.   { 0,"subfzeo",F_SUPP_B,T_X,31,0,0,(1<<10)+(200<<1)+0 },
  425.   { 0,"subfzeo.",F_SUPP_B,T_X,31,0,0,(1<<10)+(200<<1)+1 },
  426.   { 0,"sync",F_SUPP_D|F_SUPP_A|F_SUPP_B,T_X,31,0,0,(598<<1) },
  427.   { 0,"td",F_64BIT,T_X,31,0,0,(68<<1) },
  428.   { 0,"tdi",F_SIGNED|F_64BIT,T_DI,2,0,0,0 },
  429.   { 0,"tlbia",F_SUPP_D|F_SUPP_A|F_SUPP_B|F_SUPER|F_OPTIONAL,
  430.     T_X,31,0,0,(370<<1) },
  431.   { 0,"tlbie",F_SUPP_D|F_SUPP_A|F_SUPER|F_OPTIONAL,T_X,31,0,0,(306<<1) },
  432.   { 0,"tlsync",F_SUPP_D|F_SUPP_A|F_SUPP_B|F_SUPER|F_OPTIONAL,
  433.     T_X,31,0,0,(566<<1) },
  434.   { 0,"tw",0,T_X,31,0,0,(4<<1) },
  435.   { 0,"twi",F_SIGNED,T_DI,3,0,0,0 },
  436.   { 0,"xor",F_SWAP,T_X,31,0,0,(316<<1)+0 },
  437.   { 0,"xor.",F_SWAP,T_X,31,0,0,(316<<1)+1 },
  438.   { 0,"xori",F_SWAP,T_DI,26,0,0,0 },
  439.   { 0,"xoris",F_SWAP,T_DI,27,0,0,0 },
  440.  
  441.   /* extended mnemonics, rest is implemented as predefined macros */
  442.   { 0,"la",F_EXTENDED,T_DD,14,0,0,0 },
  443.   { 0,0 } /* end mark */
  444. };
  445.  
  446.  
  447.  
  448. void instr(struct GlobalVars *gv,struct ParsedLine *pl)
  449. {
  450.   struct CPUInstr *ins=(struct CPUInstr *)pl->opcode;
  451.   char *op=pl->operand;
  452.   uint32 d=ins->fieldD,a=ins->fieldA;
  453.   uint32 b=0,c=0,x=0;
  454.   uint32 oc=ins->opcd<<26;
  455.   uint32 xo=ins->xo;
  456.   uint16 flags=ins->flags;
  457.   char *oldop=op;
  458.   struct Expression exp;
  459.   bool signchk=TRUE;
  460.  
  461.   if (flags & F_64BIT)
  462.     if (!gv->sixtyfourmode)
  463.       error(37,ins->name);  /* warning: 64-bit instruction */
  464.   if (flags & F_OPTIONAL)
  465.     if (!gv->optinstrmode)
  466.       error(38,ins->name);  /* warning: optional instruction */
  467.   if (flags & F_SUPER)
  468.     if (!gv->supermode)
  469.       error(39,ins->name);  /* warning: supervisor-level instruction */
  470.   gv->signedexp = flags&F_SIGNED ? TRUE:FALSE;
  471.  
  472.   switch (ins->type) {
  473.   
  474.     case T_I:  /* Bx */
  475.       op = eval_expression(gv,&exp,op);
  476.       if (exp.type < SYM_RELOC)
  477.         switch (exp.type) {
  478.           case SYM_UNDEF:
  479.             error(19);  /* undefined symbol */
  480.             break;
  481.           case SYM_ABS:
  482.             error(32);  /* Reloc symbol required */
  483.             break;
  484.         }
  485.       if (flags & F_SIGNED) {  /* relative branch */
  486.         exp.reloctype = R_PPC_REL24;
  487.         switch (exp.type) {
  488.           case SYM_RELOC:
  489.             if (exp.symbol->relsect == gv->csect)
  490.               x = exp.value - gv->csect->pc;  /* branch distance */
  491.             else {
  492.               error(33);  /* branch destination is not in current section */
  493.               x = makereloc(gv,&exp);
  494.             }
  495.             break;
  496.           case SYM_EXTERN:
  497.             x = makexref(gv,&exp,3);
  498.             break;
  499.         }
  500.         checkrange(x,3,TRUE);
  501.       }
  502.       else {  /* absolute branch */
  503.         exp.reloctype = R_PPC_ADDR24;
  504.         switch (exp.type) {
  505.           case SYM_RELOC:
  506.             x = makereloc(gv,&exp);
  507.             break;
  508.           case SYM_EXTERN:
  509.             x = makexref(gv,&exp,3);
  510.             break;
  511.         }
  512.         checkrange(x,3,FALSE);        
  513.       }
  514.       oc |= (x&0x3fffffc)|xo;
  515.       break;
  516.  
  517.     case T_B:  /* BCx */
  518.       op = getintexp(gv,op,&d);  /* BO, branch operand */
  519.       if (!(op = check_comma(op)))
  520.         break;
  521.       op = getintexp(gv,op,&a);  /* BI, branch condition index */
  522.       if (!(op = check_comma(op)))
  523.         break;
  524.       op = eval_expression(gv,&exp,op);
  525.       if (exp.type < SYM_RELOC)
  526.         switch (exp.type) {
  527.           case SYM_UNDEF:
  528.             error(19);  /* undefined symbol */
  529.             break;
  530.           case SYM_ABS:
  531.             error(32);  /* Reloc symbol required */
  532.             break;
  533.         }
  534.       if (flags & F_SIGNED) {  /* relative branch */
  535.         exp.reloctype = R_PPC_REL14;
  536.         switch (exp.type) {
  537.           case SYM_RELOC:
  538.             if (exp.symbol->relsect == gv->csect)
  539.               x = exp.value - gv->csect->pc;  /* branch distance */
  540.             else {
  541.               error(33);  /* branch destination is not in current section */
  542.               x = makereloc(gv,&exp);
  543.             }
  544.             break;
  545.           case SYM_EXTERN:
  546.             x = makexref(gv,&exp,2);
  547.             break;
  548.         }
  549.         checkrange(x,2,TRUE);
  550.       }
  551.       else {  /* absolute branch */
  552.         exp.reloctype = R_PPC_ADDR14;
  553.         switch (exp.type) {
  554.           case SYM_RELOC:
  555.             x = makereloc(gv,&exp);
  556.             break;
  557.           case SYM_EXTERN:
  558.             x = makexref(gv,&exp,2);
  559.             break;
  560.         }
  561.         checkrange(x,2,FALSE);        
  562.       }
  563.       if (flags & F_SIGNED) {
  564.         if ((int32)x >= 0)
  565.           d &= ~1;
  566.         else
  567.           d |= 1;
  568.       }
  569.       else {
  570.         if (x < gv->csect->pc && exp.symbol->relsect == gv->csect)
  571.           d |= 1;
  572.         else
  573.           d &= ~1;
  574.       }
  575.       if (pl->branch_hint > 0)  /* + */
  576.         d ^= 1;
  577.       x &= 0xfffc;
  578.       if (gv->output == OFMT_EHF)  /* hack to allow correct EHF relocation */
  579.         x += 2;
  580.       if (d>31 || a>31)
  581.         error(34);  /* Branch operand out of range */
  582.       else
  583.         oc |= (d<<21)|(a<<16)|x|xo;
  584.       break;
  585.  
  586.     case T_XLB:  /* BCLRx,BCCTRx */
  587.       op = getintexp(gv,op,&d);  /* BO, branch operand */
  588.       if (!(op = check_comma(op)))
  589.         break;
  590.       op = getintexp(gv,op,&a);  /* BI, branch condition index */
  591.       if (pl->branch_hint > 0)
  592.         d |= 1;
  593.       else if (pl->branch_hint < 0)
  594.         d &= ~1;
  595.       if (d>31 || a>31)
  596.         error(34);  /* Branch operand out of range */
  597.       else
  598.         oc |= (d<<21)|(a<<16)|xo;
  599.       break;
  600.  
  601.     case T_CMP:  /* CMP, CMPI, CMPL, CMPLI */
  602.       if (count_operands(gv,op) > 3) {  /* CR-field specified? */
  603.         op = getintexp(gv,op,&d);
  604.         if (!(op = check_comma(op)))
  605.           break;
  606.       }
  607.       op = getintexp(gv,op,&c);  /* L = word or double word */
  608.       if (!(op = check_comma(op)))
  609.         break;
  610.       op = getintexp(gv,op,&a);
  611.       if (!(op = check_comma(op)))
  612.         break;
  613.       if (flags & F_SUPP_B) {  /* immediate comparison */
  614.         op = getexp(gv,op,&x,2);
  615.         checkrange(x,2,flags&F_SIGNED);
  616.       }
  617.       else  /* register comparison */
  618.         op = getintexp(gv,op,&b);
  619.       if (d>7)
  620.         error(35);  /* CR-specifier out of range */
  621.       else if (c>1)
  622.         error(36,"L");  /* Operand field out of range */
  623.       else if (a>31 || b>31)
  624.         error(31);  /* register operand out of range */
  625.       else if (flags & F_SUPP_B)
  626.         oc |= (d<<23)|(c<<21)|(a<<16)|(x&0xffff);
  627.       else
  628.         oc |= (d<<23)|(c<<21)|(a<<16)|(b<<11)|xo;
  629.       break;
  630.  
  631.     case T_DI:  /* ADDI,ANDI,ORI */
  632.       op = getintexp(gv,op,&d);
  633.       if (!(op = check_comma(op)))
  634.         break;
  635.       op = getintexp(gv,op,&a);
  636.       if (!(op = check_comma(op)))
  637.         break;
  638.       op = getexp(gv,op,&x,2);
  639.       if (flags & F_SWAP)
  640.         swapops(&d,&a);
  641.       checkrange(x,2,flags&F_SIGNED);
  642.       if (d>31 || a>31)
  643.         error(31);  /* register operand out of range */
  644.       else
  645.         oc |= (d<<21)|(a<<16)|(x&0xffff);
  646.       break;
  647.  
  648.     case T_X:  /* ADDx, ANDx, DIVx, FMRx, .. */
  649.       if (!(flags & F_SUPP_D))
  650.         op = getintexp(gv,op,&d);
  651.       if (!(flags & F_SUPP_A)) {
  652.         if (op != oldop)
  653.           if (!(op = check_comma(op)))
  654.             break;
  655.         op = getintexp(gv,op,&a);
  656.       }
  657.       if (!(flags & F_SUPP_B)) {
  658.         if (op != oldop)
  659.           if (!(op = check_comma(op)))
  660.             break;
  661.         op = getintexp(gv,op,&b);
  662.       }
  663.       if (flags & F_CRF_D)
  664.         d <<= 2;
  665.       if (flags & F_CRF_S)
  666.         a <<= 2;
  667.       if (flags & F_SWAP)
  668.         swapops(&d,&a);
  669.       if (d>31 || a>31 || b>31)
  670.         error(31);
  671.       else
  672.         oc |= (d<<21)|(a<<16)|(b<<11)|xo;
  673.       break;
  674.  
  675.     case T_A:  /* FADDx, FSUBx, FMULx, FDIVx, .. */
  676.       if (!(flags & F_SUPP_D))
  677.         op = getintexp(gv,op,&d);
  678.       if (!(flags & F_SUPP_A)) {
  679.         if (op != oldop)
  680.           if (!(op = check_comma(op)))
  681.             break;
  682.         op = getintexp(gv,op,&a);
  683.       }
  684.       if (!(flags & F_SUPP_C)) {
  685.         if (op != oldop)
  686.           if (!(op = check_comma(op)))
  687.             break;
  688.         op = getintexp(gv,op,&c);
  689.       }
  690.       if (!(flags & F_SUPP_B)) {
  691.         if (op != oldop)
  692.           if (!(op = check_comma(op)))
  693.             break;
  694.         op = getintexp(gv,op,&b);
  695.       }
  696.       if (flags & F_SWAP) {  /* rldcl/rldcr rA,rS,rB,mb */
  697.         swapops(&d,&a);
  698.         swapops(&c,&b);
  699.       }
  700.       if (d>31 || a>31 || b>31 || c>31)
  701.         error(31);
  702.       else
  703.         oc |= (d<<21)|(a<<16)|(b<<11)|(c<<6)|xo;
  704.       break;
  705.  
  706.     case T_DD:  /* LBZ, LHA, LZWU, STBU, STW, .. */
  707.       op = getintexp(gv,op,&d);
  708.       if (!(op = check_comma(op)))
  709.         break;
  710.       if (chk_regindir(op)) {   /* rD,(rA) -> rD,0(rA) */
  711.         exp.value = 0;
  712.         exp.type = SYM_ABS;
  713.       }
  714.       else
  715.         op = eval_expression(gv,&exp,op);
  716.       if (*op++ == '(') {
  717.         op = getintexp(gv,op,&a);
  718.         if (*op++ != ')') {
  719.           error(40);  /* (rA) expected, after index expression */
  720.           op = NULL;
  721.           break;
  722.         }
  723.         if (exp.type != SYM_UNDEF) {
  724.           switch (exp.type) {
  725.             case SYM_RELOC:
  726.               if (exp.reloctype == R_PPC_ADDR16_LO) {  /* sym@l */
  727.                 x = makereloc(gv,&exp);
  728.                 signchk = FALSE;
  729.                 break;
  730.               }
  731.               else if (exp.symbol->relsect == gv->tocsect) {
  732.                 if ((int)a == gv->rtoc) {  /* valid ref. to rtoc symbol */
  733.                   exp.reloctype = R_PPC_TOC16;
  734.                   x = makereloc(gv,&exp);
  735.                   break;
  736.                 }
  737.               }
  738.               error(46);  /* symbol is not part of a base-relative section */
  739.               break;
  740.             case SYM_EXTERN:  /* reference to external symbol */
  741.               if (exp.reloctype != R_PPC_ADDR16_LO)
  742.                 exp.reloctype = R_PPC_ADDR16;
  743.               else if ((int)a == gv->rtoc)   /* ext. symbol via rtoc - */
  744.                 exp.reloctype = R_PPC_TOC16; /* might be a TOC16 ref.  */
  745.               x = makexref(gv,&exp,2);
  746.               break;
  747.             default:  /* SYM_ABS */
  748.               x = exp.value;
  749.               break;
  750.           }
  751.         }
  752.         else
  753.           error(19);  /* undefined symbol */
  754.       }
  755.       else {  /* rD,v -> rD,v_off(rtoc) */
  756.         if (exp.type != SYM_UNDEF) {
  757.           switch (exp.type) {
  758.             case SYM_RELOC:
  759.               if (exp.symbol->relsect == gv->tocsect) {
  760.                 a = gv->rtoc;
  761.                 exp.reloctype = R_PPC_TOC16;
  762.                 x = makereloc(gv,&exp);
  763.                 break;
  764.               }
  765.               error(46);
  766.               break;
  767.             case SYM_EXTERN:  /* we assume that this is a TOC16 reference */
  768.               a = gv->rtoc;
  769.               exp.reloctype = R_PPC_TOC16;
  770.               x = makexref(gv,&exp,2);
  771.               break;
  772.             default:
  773.               error(46);
  774.               break;
  775.           }
  776.         }
  777.         else
  778.           error(19);
  779.       }
  780.       checkrange(x,2,signchk);
  781.       if (d>31 || a>31)
  782.         error(31);  /* register operand out of range */
  783.       else
  784.         oc |= (d<<21)|(a<<16)|(x&0xffff);
  785.       break;
  786.  
  787.     case T_DS:  /* LD, LDU, LWA, STD , .. */
  788.       op = getintexp(gv,op,&d);
  789.       if (!(op = check_comma(op)))
  790.         break;
  791.       if (chk_regindir(op)) {   /* rD,(rA) -> rD,0(rA) */
  792.         exp.value = 0;
  793.         exp.type = SYM_ABS;
  794.       }
  795.       else
  796.         op = eval_expression(gv,&exp,op);
  797.       if (*op++ == '(') {
  798.         op = getintexp(gv,op,&a);
  799.         if (*op++ != ')') {
  800.           error(40);  /* (rA) expected, after index expression */
  801.           op = NULL;
  802.           break;
  803.         }
  804.         if (exp.type != SYM_UNDEF) {
  805.           switch (exp.type) {
  806.             case SYM_RELOC:
  807.               if (exp.reloctype == R_PPC_ADDR16_LO) {  /* sym@l */
  808.                 x = makereloc(gv,&exp);
  809.                 signchk = FALSE;
  810.                 break;
  811.               }
  812.               else if (exp.symbol->relsect == gv->tocsect) {
  813.                 if ((int)a == gv->rtoc) {  /* valid ref. to rtoc symbol */
  814.                   exp.reloctype = R_PPC_TOC16;
  815.                   x = makereloc(gv,&exp);
  816.                   break;
  817.                 }
  818.               }
  819.               error(46);  /* symbol is not part of a base-relative section */
  820.               break;
  821.             case SYM_EXTERN:  /* reference to external symbol */
  822.               if (exp.reloctype != R_PPC_ADDR16_LO)
  823.                 exp.reloctype = R_PPC_ADDR16;
  824.               else if ((int)a == gv->rtoc)   /* ext. symbol via rtoc - */
  825.                 exp.reloctype = R_PPC_TOC16; /* might be a TOC16 ref.  */
  826.               x = makexref(gv,&exp,2);
  827.               break;
  828.             default:  /* SYM_ABS */
  829.               x = exp.value;
  830.               break;
  831.           }
  832.         }
  833.         else
  834.           error(19);  /* undefined symbol */
  835.       }
  836.       else {  /* rD,v -> rD,v_off(rtoc) */
  837.         if (exp.type != SYM_UNDEF) {
  838.           switch (exp.type) {
  839.             case SYM_RELOC:
  840.               if (exp.symbol->relsect == gv->tocsect) {
  841.                 a = gv->rtoc;
  842.                 exp.reloctype = R_PPC_TOC16;
  843.                 x = makereloc(gv,&exp);
  844.                 break;
  845.               }
  846.               error(46);
  847.               break;
  848.             case SYM_EXTERN:  /* we assume that this is a TOC16 reference */
  849.               a = gv->rtoc;
  850.               exp.reloctype = R_PPC_TOC16;
  851.               x = makexref(gv,&exp,2);
  852.               break;
  853.             default:
  854.               error(46);
  855.               break;
  856.           }
  857.         }
  858.         else
  859.           error(19);
  860.       }
  861.       checkrange(x,2,signchk);
  862.       if (x & 3)
  863.         error(41);  /* expression must be dividable by four */
  864.       else if (d>31 || a>31)
  865.         error(31);  /* register operand out of range */
  866.       else
  867.         oc |= (d<<21)|(a<<16)|(x&0xfffc)|xo;
  868.       break;
  869.  
  870.     case T_XSPR:  /* MFSPR, MTSPR */
  871.       op = getintexp(gv,op,&d);
  872.       if (!(op = check_comma(op)))
  873.         break;
  874.       op = getintexp(gv,op,&a);
  875.       if (flags & F_SWAP)
  876.         swapops(&d,&a);
  877.       if (d>31 || a>0x3ff)
  878.         error(31);
  879.       else
  880.         oc |= (d<<21)|((a&0x1f)<<16)|((a&0x3e0)<<6)|xo;
  881.       break;
  882.  
  883.     case T_XCRM:  /* MFCRF */
  884.       op = getintexp(gv,op,&x);
  885.       if (!(op = check_comma(op)))
  886.         break;
  887.       op = getintexp(gv,op,&d);
  888.       if (x > 0xff)
  889.         error(42);  /* invalid register field mask */
  890.       else if (a>31)
  891.         error(31);
  892.       else
  893.         oc |= (d<<21)|(x<<12)|xo;
  894.       break;
  895.  
  896.     case T_XFL:  /* MTFSF */
  897.       op = getintexp(gv,op,&x);
  898.       if (!(op = check_comma(op)))
  899.         break;
  900.       op = getintexp(gv,op,&b);
  901.       if (x > 0xff)
  902.         error(42);  /* invalid register field mask */
  903.       else if (b>31)
  904.         error(31);
  905.       else
  906.         oc |= (x<<17)|(b<<11)|xo;
  907.       break;
  908.  
  909.     case T_IMM:  /* MTFSFI */
  910.       op = getintexp(gv,op,&d);
  911.       if (!(op = check_comma(op)))
  912.         break;
  913.       op = getintexp(gv,op,&b);
  914.       if (b>15)
  915.         error(36,"IMM");  /* operand field out of range */
  916.       else if (d>7)
  917.         error(31);
  918.       else
  919.         oc |= (d<<23)|(b<<12)|xo;
  920.       break;
  921.  
  922.     case T_MD:  /* RLDIC, .. */
  923.       op = getintexp(gv,op,&a);
  924.       if (!(op = check_comma(op)))
  925.         break;
  926.       op = getintexp(gv,op,&d);
  927.       if (!(op = check_comma(op)))
  928.         break;
  929.       op = getintexp(gv,op,&b);
  930.       if (!(op = check_comma(op)))
  931.         break;
  932.       op = getintexp(gv,op,&c);
  933.       if (b>63)
  934.         error(36,"SH");  /* operand field out of range */
  935.       else if (c>31)
  936.         error(36,"MB/ME");
  937.       else if (d>31 || a>31)
  938.         error(31);
  939.       else
  940.         oc |= (d<<21)|(a<<16)|((b&0x1f)<<11)|(c<<6)|xo|((b&0x20)>>4);
  941.       break;
  942.  
  943.     case T_M:  /* RLWINM, RLWNM, RLWIMI, .. */
  944.       op = getintexp(gv,op,&a);
  945.       if (!(op = check_comma(op)))
  946.         break;
  947.       op = getintexp(gv,op,&d);
  948.       if (!(op = check_comma(op)))
  949.         break;
  950.       op = getintexp(gv,op,&b);
  951.       if (!(op = check_comma(op)))
  952.         break;
  953.       op = getintexp(gv,op,&c);
  954.       if (!(op = check_comma(op)))
  955.         break;
  956.       op = getintexp(gv,op,&x);
  957.       if (b>31)
  958.         error(36,"SH/rB");  /* operand field out of range */
  959.       else if (c>31)
  960.         error(36,"MB");
  961.       else if (c>31)
  962.         error(36,"ME");
  963.       else if (d>31 || a>31)
  964.         error(31);
  965.       else
  966.         oc |= (d<<21)|(a<<16)|(b<<11)|(c<<6)|(x<<1)|xo;
  967.       break;
  968.  
  969.     case T_XS:  /* SRADIx */
  970.       op = getintexp(gv,op,&a);
  971.       if (!(op = check_comma(op)))
  972.         break;
  973.       op = getintexp(gv,op,&d);
  974.       if (!(op = check_comma(op)))
  975.         break;
  976.       op = getintexp(gv,op,&b);
  977.       if (b>63)
  978.         error(36,"SH");  /* operand field out of range */
  979.       else if (d>31 || a>31)
  980.         error(31);
  981.       else
  982.         oc |= (d<<21)|(a<<16)|((b&0x1f)<<11)|xo|((b&0x20)>>4);
  983.       break;
  984.   }
  985.  
  986.   store_word(gv,oc);
  987.   if (op)
  988.     checkEOL(op);
  989. }
  990.  
  991.  
  992. static void swapops(uint32 *a,uint32 *b)
  993. {
  994.   uint32 c = *a;
  995.  
  996.   *a = *b;
  997.   *b = c;
  998. }
  999.  
  1000.  
  1001. static int count_operands(struct GlobalVars *gv,char *s)
  1002. {
  1003.   int n=0;
  1004.  
  1005.   if (*s!=0 && *s!='#')
  1006.     do {
  1007.       n++;
  1008.       s = skipexpression(gv,s);
  1009.     }
  1010.     while (*s++ == ',');
  1011.   return (n);
  1012. }
  1013.  
  1014.  
  1015. static bool chk_regindir(char *s)
  1016. /* "(...)\0" has a high probability to be a register-indirect */
  1017. /* addressing mode. */
  1018. {
  1019.   char c;
  1020.  
  1021.   if (*s++ == '(') {
  1022.     while (c = *s++) {
  1023.       if (c == '(')
  1024.         break;           /* "((..." will never be register-indirect */
  1025.       if (c == ')') {
  1026.         s = skipspaces(s);
  1027.         if (*s == '\0')  /* line ends directly after "(...)" ? */
  1028.           return (TRUE);
  1029.         else
  1030.           break;
  1031.       }
  1032.     }
  1033.   }
  1034.   return (FALSE);
  1035. }
  1036.  
  1037.  
  1038. char *check_comma(char *s)
  1039. {
  1040.   s = skipspaces(s);
  1041.   if (*s++ != ',') {
  1042.     error(27);  /* instruction has too few operands */
  1043.     return (NULL);
  1044.   }
  1045.   s = skipspaces(s);
  1046.   return (s);
  1047. }
  1048.  
  1049.  
  1050. void pcadd(struct GlobalVars *gv,unsigned long offset)
  1051. {
  1052.   gv->csect->pc += offset;
  1053. }
  1054.  
  1055.  
  1056. void store_byte(struct GlobalVars *gv,uint8 x)
  1057. {
  1058.   struct Section *sec = gv->csect;
  1059.   uint8 *d = (uint8 *)sec->data;
  1060.  
  1061.   if (!(sec->flags & SF_UNINITIALIZED)) {
  1062.     *d++ = x;
  1063.     sec->data = d;
  1064.   }
  1065.   sec->pc += 1;
  1066.   gv->lcsym->value += 1;
  1067. }
  1068.  
  1069.  
  1070. void store_half(struct GlobalVars *gv,uint16 x)
  1071. {
  1072.   struct Section *sec = gv->csect;
  1073.   uint16 *d = (uint16 *)sec->data;
  1074.  
  1075.   if (!(sec->flags & SF_UNINITIALIZED)) {
  1076.     *d++ = ECVH(x);
  1077.     sec->data = d;
  1078.   }
  1079.   sec->pc += 2;
  1080.   gv->lcsym->value += 2;
  1081. }
  1082.  
  1083.  
  1084. void store_word(struct GlobalVars *gv,uint32 x)
  1085. {
  1086.   struct Section *sec = gv->csect;
  1087.   uint32 *d = (uint32 *)sec->data;
  1088.  
  1089.   if (!(sec->flags & SF_UNINITIALIZED)) {
  1090.     *d++ = ECVW(x);
  1091.     sec->data = d;
  1092.   }
  1093.   sec->pc += 4;
  1094.   gv->lcsym->value += 4;
  1095. }
  1096.  
  1097.  
  1098. void store_float(struct GlobalVars *gv,double x)
  1099. {
  1100.   struct Section *sec = gv->csect;
  1101.   float *d = (float *)sec->data;
  1102.  
  1103.   if (!(sec->flags & SF_UNINITIALIZED)) {
  1104.     *d++ = (float)x;
  1105.     sec->data = d;
  1106.   }
  1107.   sec->pc += 4;
  1108.   gv->lcsym->value += 4;
  1109. }
  1110.  
  1111.  
  1112. void store_double(struct GlobalVars *gv,double x)
  1113. {
  1114.   struct Section *sec = gv->csect;
  1115.   double *d = (double *)sec->data;
  1116.  
  1117.   if (!(sec->flags & SF_UNINITIALIZED)) {
  1118.     *d++ = x;
  1119.     sec->data = d;
  1120.   }
  1121.   sec->pc += 8;
  1122.   gv->lcsym->value += 8;
  1123. }
  1124.  
  1125.  
  1126. void store_space(struct GlobalVars *gv,unsigned long n)
  1127. {
  1128.   struct Section *sec = gv->csect;
  1129.   uint8 *d = (uint8 *)sec->data;
  1130.  
  1131.   sec->pc += n;
  1132.   gv->lcsym->value += n;
  1133.   if (!(sec->flags & SF_UNINITIALIZED)) {
  1134.     while (n--)
  1135.       *d++ = 0;
  1136.     sec->data = d;
  1137.   }
  1138. }
  1139.